// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/process/process_metrics.h"

#include <psapi.h>
#include <stddef.h>
#include <stdint.h>
#include <windows.h>
#include <winternl.h>

#include <algorithm>

#include "base/logging.h"
#include "base/sys_info.h"

inline BOOL GetProcessMemoryInfoXp(HANDLE Process, void* ppsmemCounters, DWORD cb)
{
    typedef BOOL(__stdcall* PFN_GetProcessMemoryInfo)(HANDLE Process, void* ppsmemCounters, DWORD cb);
    static PFN_GetProcessMemoryInfo s_GetProcessMemoryInfo = NULL;

    static BOOL s_is_init = FALSE;
    if (!s_is_init) {
        HMODULE handle = GetModuleHandle(L"Kernel32.dll");
        s_GetProcessMemoryInfo = (PFN_GetProcessMemoryInfo)GetProcAddress(handle, "GetProcessMemoryInfo");
        if (!s_GetProcessMemoryInfo) {
            handle = LoadLibraryW(L"Psapi.dll");
            s_GetProcessMemoryInfo = (PFN_GetProcessMemoryInfo)GetProcAddress(handle, "GetProcessMemoryInfo");
        }
        s_is_init = TRUE;
    }

    if (s_GetProcessMemoryInfo)
        return s_GetProcessMemoryInfo(Process, ppsmemCounters, cb);

    return FALSE;
}

namespace base {
namespace {

    // System pagesize. This value remains constant on x86/64 architectures.
    const int PAGESIZE_KB = 4;

    typedef NTSTATUS(WINAPI* NTQUERYSYSTEMINFORMATION)(
        SYSTEM_INFORMATION_CLASS SystemInformationClass,
        PVOID SystemInformation,
        ULONG SystemInformationLength,
        PULONG ReturnLength);

} // namespace

SystemMemoryInfoKB::SystemMemoryInfoKB()
{
    total = 0;
    free = 0;
    swap_total = 0;
    swap_free = 0;
}

SystemMemoryInfoKB::SystemMemoryInfoKB(const SystemMemoryInfoKB& other) = default;

ProcessMetrics::~ProcessMetrics() { }

// static
ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process)
{
    return new ProcessMetrics(process);
}

size_t ProcessMetrics::GetPagefileUsage() const
{
    PROCESS_MEMORY_COUNTERS pmc;
    if (GetProcessMemoryInfoXp(process_, &pmc, sizeof(pmc))) {
        return pmc.PagefileUsage;
    }
    return 0;
}

// Returns the peak space allocated for the pagefile, in bytes.
size_t ProcessMetrics::GetPeakPagefileUsage() const
{
    PROCESS_MEMORY_COUNTERS pmc;
    if (GetProcessMemoryInfoXp(process_, &pmc, sizeof(pmc))) {
        return pmc.PeakPagefileUsage;
    }
    return 0;
}

// Returns the current working set size, in bytes.
size_t ProcessMetrics::GetWorkingSetSize() const
{
    PROCESS_MEMORY_COUNTERS pmc;
    if (GetProcessMemoryInfoXp(process_, &pmc, sizeof(pmc))) {
        return pmc.WorkingSetSize;
    }
    return 0;
}

// Returns the peak working set size, in bytes.
size_t ProcessMetrics::GetPeakWorkingSetSize() const
{
    PROCESS_MEMORY_COUNTERS pmc;
    if (GetProcessMemoryInfoXp(process_, &pmc, sizeof(pmc))) {
        return pmc.PeakWorkingSetSize;
    }
    return 0;
}

bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
    size_t* shared_bytes)
{
    // PROCESS_MEMORY_COUNTERS_EX is not supported until XP SP2.
    // GetProcessMemoryInfo() will simply fail on prior OS. So the requested
    // information is simply not available. Hence, we will return 0 on unsupported
    // OSes. Unlike most Win32 API, we don't need to initialize the "cb" member.
    PROCESS_MEMORY_COUNTERS_EX pmcx;
    if (private_bytes && GetProcessMemoryInfoXp(process_, reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&pmcx), sizeof(pmcx))) {
        *private_bytes = pmcx.PrivateUsage;
    }

    if (shared_bytes) {
        WorkingSetKBytes ws_usage;
        if (!GetWorkingSetKBytes(&ws_usage))
            return false;

        *shared_bytes = ws_usage.shared * 1024;
    }

    return true;
}

void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const
{
    MEMORY_BASIC_INFORMATION mbi = { 0 };
    size_t committed_private = 0;
    size_t committed_mapped = 0;
    size_t committed_image = 0;
    void* base_address = NULL;
    while (VirtualQueryEx(process_, base_address, &mbi, sizeof(mbi)) == sizeof(mbi)) {
        if (mbi.State == MEM_COMMIT) {
            if (mbi.Type == MEM_PRIVATE) {
                committed_private += mbi.RegionSize;
            } else if (mbi.Type == MEM_MAPPED) {
                committed_mapped += mbi.RegionSize;
            } else if (mbi.Type == MEM_IMAGE) {
                committed_image += mbi.RegionSize;
            } else {
                NOTREACHED();
            }
        }
        void* new_base = (static_cast<BYTE*>(mbi.BaseAddress)) + mbi.RegionSize;
        // Avoid infinite loop by weird MEMORY_BASIC_INFORMATION.
        // If we query 64bit processes in a 32bit process, VirtualQueryEx()
        // returns such data.
        if (new_base <= base_address) {
            usage->image = 0;
            usage->mapped = 0;
            usage->priv = 0;
            return;
        }
        base_address = new_base;
    }
    usage->image = committed_image / 1024;
    usage->mapped = committed_mapped / 1024;
    usage->priv = committed_private / 1024;
}

bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const
{
    DebugBreak();
    return false;
//     size_t ws_private = 0;
//     size_t ws_shareable = 0;
//     size_t ws_shared = 0;
// 
//     DCHECK(ws_usage);
//     memset(ws_usage, 0, sizeof(*ws_usage));
// 
//     DWORD number_of_entries = 4096; // Just a guess.
//     PSAPI_WORKING_SET_INFORMATION* buffer = NULL;
//     int retries = 5;
//     for (;;) {
//         DWORD buffer_size = sizeof(PSAPI_WORKING_SET_INFORMATION) + (number_of_entries * sizeof(PSAPI_WORKING_SET_BLOCK));
// 
//         // if we can't expand the buffer, don't leak the previous
//         // contents or pass a NULL pointer to QueryWorkingSet
//         PSAPI_WORKING_SET_INFORMATION* new_buffer = reinterpret_cast<PSAPI_WORKING_SET_INFORMATION*>(
//             realloc(buffer, buffer_size));
//         if (!new_buffer) {
//             free(buffer);
//             return false;
//         }
//         buffer = new_buffer;
// 
//         // Call the function once to get number of items
//         if (QueryWorkingSet(process_, buffer, buffer_size))
//             break; // Success
// 
//         if (GetLastError() != ERROR_BAD_LENGTH) {
//             free(buffer);
//             return false;
//         }
// 
//         number_of_entries = static_cast<DWORD>(buffer->NumberOfEntries);
// 
//         // Maybe some entries are being added right now. Increase the buffer to
//         // take that into account.
//         number_of_entries = static_cast<DWORD>(number_of_entries * 1.25);
// 
//         if (--retries == 0) {
//             free(buffer); // If we're looping, eventually fail.
//             return false;
//         }
//     }
// 
//     // On windows 2000 the function returns 1 even when the buffer is too small.
//     // The number of entries that we are going to parse is the minimum between the
//     // size we allocated and the real number of entries.
//     number_of_entries = std::min(number_of_entries, static_cast<DWORD>(buffer->NumberOfEntries));
//     for (unsigned int i = 0; i < number_of_entries; i++) {
//         if (buffer->WorkingSetInfo[i].Shared) {
//             ws_shareable++;
//             if (buffer->WorkingSetInfo[i].ShareCount > 1)
//                 ws_shared++;
//         } else {
//             ws_private++;
//         }
//     }
// 
//     ws_usage->priv = ws_private * PAGESIZE_KB;
//     ws_usage->shareable = ws_shareable * PAGESIZE_KB;
//     ws_usage->shared = ws_shared * PAGESIZE_KB;
//     free(buffer);
//     return true;
}

static uint64_t FileTimeToUTC(const FILETIME& ftime)
{
    LARGE_INTEGER li;
    li.LowPart = ftime.dwLowDateTime;
    li.HighPart = ftime.dwHighDateTime;
    return li.QuadPart;
}

double ProcessMetrics::GetCPUUsage()
{
    FILETIME creation_time;
    FILETIME exit_time;
    FILETIME kernel_time;
    FILETIME user_time;

    if (!GetProcessTimes(process_, &creation_time, &exit_time,
            &kernel_time, &user_time)) {
        // We don't assert here because in some cases (such as in the Task Manager)
        // we may call this function on a process that has just exited but we have
        // not yet received the notification.
        return 0;
    }
    int64_t system_time = (FileTimeToUTC(kernel_time) + FileTimeToUTC(user_time)) / processor_count_;
    TimeTicks time = TimeTicks::Now();

    if (last_system_time_ == 0) {
        // First call, just set the last values.
        last_system_time_ = system_time;
        last_cpu_time_ = time;
        return 0;
    }

    int64_t system_time_delta = system_time - last_system_time_;
    // FILETIME is in 100-nanosecond units, so this needs microseconds times 10.
    int64_t time_delta = (time - last_cpu_time_).InMicroseconds() * 10;
    DCHECK_NE(0U, time_delta);
    if (time_delta == 0)
        return 0;

    last_system_time_ = system_time;
    last_cpu_time_ = time;

    return static_cast<double>(system_time_delta * 100.0) / time_delta;
}

bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const
{
    return GetProcessIoCounters(process_, io_counters) != FALSE;
}

ProcessMetrics::ProcessMetrics(ProcessHandle process)
    : process_(process)
    , processor_count_(base::SysInfo::NumberOfProcessors())
    , last_system_time_(0)
{
}

// GetPerformanceInfo is not available on WIN2K.  So we'll
// load it on-the-fly.
const wchar_t kPsapiDllName[] = L"psapi.dll";
typedef BOOL(WINAPI* GetPerformanceInfoFunction)(
    PPERFORMANCE_INFORMATION pPerformanceInformation,
    DWORD cb);

// Beware of races if called concurrently from multiple threads.
static BOOL InternalGetPerformanceInfo(
    PPERFORMANCE_INFORMATION pPerformanceInformation, DWORD cb)
{
    static GetPerformanceInfoFunction GetPerformanceInfo_func = NULL;
    if (!GetPerformanceInfo_func) {
        HMODULE psapi_dll = ::GetModuleHandle(kPsapiDllName);
        if (psapi_dll)
            GetPerformanceInfo_func = reinterpret_cast<GetPerformanceInfoFunction>(
                GetProcAddress(psapi_dll, "GetPerformanceInfo"));

        if (!GetPerformanceInfo_func) {
            // The function could not be loaded!
            memset(pPerformanceInformation, 0, cb);
            return FALSE;
        }
    }
    return GetPerformanceInfo_func(pPerformanceInformation, cb);
}

size_t GetSystemCommitCharge()
{
    // Get the System Page Size.
    SYSTEM_INFO system_info;
    GetSystemInfo(&system_info);

    PERFORMANCE_INFORMATION info;
    if (!InternalGetPerformanceInfo(&info, sizeof(info))) {
        DLOG(ERROR) << "Failed to fetch internal performance info.";
        return 0;
    }
    return (info.CommitTotal * system_info.dwPageSize) / 1024;
}

size_t GetPageSize()
{
    return PAGESIZE_KB * 1024;
}

// This function uses the following mapping between MEMORYSTATUSEX and
// SystemMemoryInfoKB:
//   ullTotalPhys ==> total
//   ullAvailPhys ==> free
//   ullTotalPageFile ==> swap_total
//   ullAvailPageFile ==> swap_free
bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo)
{
    MEMORYSTATUSEX mem_status;
    mem_status.dwLength = sizeof(mem_status);
    if (!::GlobalMemoryStatusEx(&mem_status))
        return false;

    meminfo->total = mem_status.ullTotalPhys / 1024;
    meminfo->free = mem_status.ullAvailPhys / 1024;
    meminfo->swap_total = mem_status.ullTotalPageFile / 1024;
    meminfo->swap_free = mem_status.ullAvailPageFile / 1024;

    return true;
}

} // namespace base
